#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iconv.h>
#include <gtk-2.0/gtk/gtk.h>

#define TAILLE_LANGUE_1 31 //définit le nombre d'octets que peut contenir les mots de la 1ere langue du dico
#define TAILLE_LANGUE_2 53 //définit le nombre d'octets que peut contenir les mots de la 2eme langue du dico
#define NOMBRE_ENTRY 10

typedef char mot_langue_1[TAILLE_LANGUE_1 * 2]; //définit un nouveau type chaine de caractère pour les mots de la 1ere langue du dico
typedef char mot_langue_2[TAILLE_LANGUE_2 * 2]; //définit un nouveau type chaine de caractère pour les mots de la 2eme langue du dico

/* Définit une structure de donnée dictionnaire comportant un nombre de mots un tableau de mots et un tableau de traduction */
typedef struct {
	char * nom_fichier;
	char * nom_langue1;
	char * nom_langue2;
	long nombre_mots;
	mot_langue_1 * mot;			// Déclaration du tableau contenant tous les mots
	mot_langue_2 * traduction;	// Déclaration du tableau contenant toutes les traductions
}dico;

//////////////////////////////////////////////////////////////////////
//------------------------Variables globales------------------------//
//////////////////////////////////////////////////////////////////////
dico dictionnaire;
/* Variables Widgets */
GtkWidget * pMainWindow = NULL;
GtkWidget * pVBox_principale;
GtkWidget * pMenuBar;
GtkWidget * pMenu;
GtkWidget * pMenuItem;
GtkWidget * pImage_langue1;
GtkWidget * pLabel_langue1;
GtkWidget * pImage_langue2;
GtkWidget * pLabel_langue2;
GtkWidget * pEntry_mot[NOMBRE_ENTRY];
GtkObject * pAdjust;
GtkWidget * pScrollBar;
GtkWidget * pEntry_traduction[NOMBRE_ENTRY];
GtkWidget * pEntry_recherche;
GtkWidget * pStatusBar;

GtkWidget * pLabel_fichier;
GtkWidget * pLabel_nombre_mots;

//////////////////////////////////////////////////////////////////////
//----------------------------Prototypes----------------------------//
//////////////////////////////////////////////////////////////////////
char * convertir_vers_utf8(char * chaine, size_t taille, char * encodage);
long flength(FILE *f);
void charger_dico();
int chercher_mot(char * mot);
void vider_pEntry_recherche();
void afficher_dico(int debut);
void actualiser_labels();
void actualiser_drapeaux();
void actualiser_pScrollBar(int i);
void actualiser_range_pScrollBar();
void actualiser_barre_etat();
void actualiser_affichage(int debut);
void OnRecherche(GtkEntry *entry);
void OnScrollbarChange(GtkWidget *pWidget);
void OnIntervertir(GtkWidget *pWidget);
void OnAbout(GtkWidget * widget);
void OnOuvrir(GtkWidget * pWidget);

//////////////////////////////////////////////////////////////////////
//-------------------------------Main-------------------------------//
//////////////////////////////////////////////////////////////////////
int main(int argc, char **argv){ 
	GtkWidget * pHBox_entetes;
	GtkWidget * pBouton_intervertir;
	GtkWidget * pImage_intervertir;
	GtkWidget * pHBox_centrale;
	GtkWidget * pVBox_mots;
	GtkWidget * pVBox_traductions;
	GtkWidget * pHBox_bas;
	GtkWidget * pBouton_fermer;
	/* Initialisation de GTK+ */
    gtk_init(&argc, &argv);

    /* Création de la fenêtre */
    pMainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);

	/* Titrage, redimentionnement et positionnement de la fenêtre */
	gtk_window_set_title(GTK_WINDOW(pMainWindow), "Dictionnaire");
	gtk_window_set_default_size(GTK_WINDOW(pMainWindow), 630, 350);
	gtk_window_set_position(GTK_WINDOW(pMainWindow), GTK_WIN_POS_CENTER);
	gtk_window_set_resizable(GTK_WINDOW(pMainWindow), FALSE);
	
    /* Connexion du signal "destroy" de la fenetre */
    g_signal_connect(G_OBJECT(pMainWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    
    /* Creation de la GtkVBox contenant le menu */
    pVBox_principale = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pMainWindow), pVBox_principale);
    
    /**** Creation du menu ****/
    /* ETAPE 1 */
    pMenuBar = gtk_menu_bar_new();
    /** Premier sous-menu **/
    /* ETAPE 2 */
    pMenu = gtk_menu_new();
    /* ETAPE 3 */
    pMenuItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(OnOuvrir), (GtkWidget*) pMainWindow);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
    pMenuItem = gtk_separator_menu_item_new();
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
    pMenuItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gtk_main_quit), (GtkWidget*) pMainWindow);
		
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
    
    /* ETAPE 4 */
    pMenuItem = gtk_menu_item_new_with_label("Fichier");
    /* ETAPE 5 */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
    /* ETAPE 6 */
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

    /** Second sous-menu **/
    /* ETAPE 2 */
    pMenu = gtk_menu_new();
    /* ETAPE 3 */
    pMenuItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(OnAbout), (GtkWidget*) pMainWindow);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
    /* ETAPE 4 */
    pMenuItem = gtk_menu_item_new_with_label("Aide");
    /* ETAPE 5 */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
    /* ETAPE 6 */
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

    /* Ajout du menu a la fenetre */
    gtk_box_pack_start(GTK_BOX(pVBox_principale), pMenuBar, FALSE, FALSE, 0);

    /* Creation de la GtkBox horizontale pour les entêtes */
    pHBox_entetes = gtk_hbox_new(FALSE, 0);
    /* Ajout de la GtkHBox centrale dans la GtkVBox principale */
	gtk_box_pack_start(GTK_BOX(pVBox_principale), pHBox_entetes, FALSE, FALSE, 0);	
	
	
	/* Creation des labels d'entêtes */
	pLabel_langue1 = gtk_label_new(NULL);
	pLabel_langue2 = gtk_label_new(NULL);
	
	/* Création des images (drapeaux) */
	pImage_langue1 = gtk_image_new();
	pImage_langue2 = gtk_image_new();
	
	/* création du bouton intervertir */
	pBouton_intervertir = gtk_button_new();
	pImage_intervertir = gtk_image_new_from_file("./images/fleches.png");
	gtk_container_add(GTK_CONTAINER(pBouton_intervertir), pImage_intervertir);
	
	/*⇄⇆⇔⇌⇋*/
	/* Ajout des labels d'entêtes des drapeaux et du bouton */
	gtk_box_pack_start(GTK_BOX(pHBox_entetes), pImage_langue1, TRUE, FALSE, 0);	
	gtk_box_pack_start(GTK_BOX(pHBox_entetes), pLabel_langue1, TRUE, FALSE, 0);	
	gtk_box_pack_start(GTK_BOX(pHBox_entetes), pBouton_intervertir, TRUE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(pHBox_entetes), pImage_langue2, TRUE, FALSE, 0);		
	gtk_box_pack_start(GTK_BOX(pHBox_entetes), pLabel_langue2, TRUE, FALSE, 0);	
	gtk_label_set_use_markup(GTK_LABEL(pLabel_langue1), TRUE); // On dit que l'on utilise les balises pango
	gtk_label_set_use_markup(GTK_LABEL(pLabel_langue2), TRUE);
	
    /* Creation de la GtkBox horizontale centrale */
    pHBox_centrale = gtk_hbox_new(FALSE, 0);
    /* Ajout de la GtkHBox centrale dans la GtkVBox principale */
	gtk_box_pack_start(GTK_BOX(pVBox_principale), pHBox_centrale, FALSE, TRUE, 0);
	
    /* Creation des GtkBox verticales */
    pVBox_mots = gtk_vbox_new(FALSE, 0);
    pVBox_traductions = gtk_vbox_new(FALSE, 0);
    
    /* Creation d un GtkAdjustment */
	pAdjust = gtk_adjustment_new(0, 0, 0, 1, 1000, 1);
    /* Creation d'une scrollbar verticale*/
	pScrollBar = gtk_vscrollbar_new(GTK_ADJUSTMENT(pAdjust));
    /* Ajout des GtkVBox et de la Scrollbar dans la GtkHBox */
	gtk_box_pack_start(GTK_BOX(pHBox_centrale), pVBox_mots, TRUE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(pHBox_centrale), pScrollBar, TRUE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(pHBox_centrale), pVBox_traductions, TRUE, FALSE, 0);

	for(int i = 0; i < NOMBRE_ENTRY; i++){
		pEntry_mot[i] = gtk_entry_new();
		gtk_box_pack_start(GTK_BOX(pVBox_mots), pEntry_mot[i], FALSE, FALSE, 0);	
		pEntry_traduction[i] = gtk_entry_new();
		gtk_box_pack_start(GTK_BOX(pVBox_traductions), pEntry_traduction[i], FALSE, FALSE, 0);
	}

	gtk_widget_set_size_request(pEntry_mot[0], 310,25);
	gtk_widget_set_size_request(pEntry_traduction[0], 310,25);
	
	/* Creation de la GtkBox horizontale du bas */
	pHBox_bas = gtk_hbox_new(TRUE, 0);
	/* Ajout de la GtkHBox du bas dans la GtkVBox principale */
	gtk_box_pack_start(GTK_BOX(pVBox_principale), pHBox_bas, TRUE, FALSE, 0);

	/* Création du GtkEntry de recherche */
	pEntry_recherche = gtk_entry_new();
	/* Ajout du GtkEntry de recherche dans la GtkHbox du bas */
	gtk_box_pack_start(GTK_BOX(pHBox_bas), pEntry_recherche, TRUE, FALSE, 0);	
	g_signal_connect(G_OBJECT(pEntry_recherche), "changed", G_CALLBACK(OnRecherche), (GtkWidget*) pMainWindow);	
	
	/* Création du GtkButton fermer */
	pBouton_fermer = gtk_button_new_from_stock(GTK_STOCK_QUIT);
	/* Ajout du GtkButton fermer dans la GtkHbox du bas */
	gtk_box_pack_start(GTK_BOX(pHBox_bas), pBouton_fermer, TRUE, FALSE, 0);
	/* Connection du signal pour le bouton fermer */
	g_signal_connect(G_OBJECT(pBouton_fermer), "clicked", G_CALLBACK(gtk_main_quit), (GtkWidget*) pMainWindow);	
	
	/* Creation de la GtkBox horizontale de la barre d'état */
	pStatusBar = gtk_statusbar_new();
	pLabel_fichier = gtk_label_new("");
	pLabel_nombre_mots = gtk_label_new("");

	gtk_box_pack_end(GTK_BOX(pStatusBar), pLabel_nombre_mots, FALSE, FALSE, 0);
	//gtk_box_pack_end(GTK_BOX(pStatusBar), gtk_vseparator_new(), FALSE, FALSE, 0);
	gtk_box_pack_end(GTK_BOX(pStatusBar), pLabel_fichier, FALSE, FALSE, 0);
	
	gtk_box_pack_end(GTK_BOX(pVBox_principale), pStatusBar, FALSE, FALSE, 0);

	
	/* Connection du signal pour le bouton intervertir */
    g_signal_connect(G_OBJECT(pBouton_intervertir), "clicked", G_CALLBACK(OnIntervertir), (GtkWidget*) pMainWindow);	

	dictionnaire.nom_fichier = "Français_Anglais.wb";
	
	charger_dico();
	
	actualiser_affichage(0);
	
	/* Connexion du signal pour modification de la scrollbar */
	g_signal_connect(G_OBJECT(pScrollBar), "value-changed", G_CALLBACK(OnScrollbarChange), (GtkWidget*) pMainWindow);
    
    /* Affichage et boucle évènementielle */
    gtk_widget_show_all(pMainWindow);
	
    gtk_main();
	return EXIT_SUCCESS;
}


//////////////////////////////////////////////////////////////////////
//---------------------------charger_dico---------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui va charger les rubriques de la structure dictionnaire
// en fonction de la rubrique nom_fichier
void charger_dico(){
    int taille_mot_trad = TAILLE_LANGUE_1 + TAILLE_LANGUE_2; //nombre d'octets que prend un mot et sa traduction
	int ligne = 0;
	FILE *wb = NULL;
	int position_underscore = 0;
	int position_point = 0;
	
	/* alloue l'espace nécessaire pour location_fichier */
	char * location_fichier = (char *)malloc((strlen(dictionnaire.nom_fichier)+9)*sizeof(char *));
	
	strcpy(location_fichier, "./langue/");
	strcat(location_fichier, dictionnaire.nom_fichier);
	
	/* Ouverture du fichier wordbook */
	wb = fopen(location_fichier, "r");
	
	/* Calcul du nombre de mots traduits dans ce dico */
	dictionnaire.nombre_mots = (flength(wb) / taille_mot_trad);	//seule méthode que j'ai trouvée
	
	/* Définition de la taille du dico */
	dictionnaire.mot = (mot_langue_1 *)malloc(dictionnaire.nombre_mots * sizeof(mot_langue_1));
	/* Déclaration du tableau contenant toutes les traductions */
	dictionnaire.traduction = (mot_langue_2 *)malloc(dictionnaire.nombre_mots * sizeof(mot_langue_2));

	/* Boucle qui va parcourir le fichier wb et charger les mots et les traductions dans leur tableau respectifs */
	while(!feof(wb)){
		fread(&(dictionnaire.mot[ligne]), TAILLE_LANGUE_1, 1, wb);	
		fread(&(dictionnaire.traduction[ligne]), TAILLE_LANGUE_2, 1, wb);
		strcpy(dictionnaire.mot[ligne], convertir_vers_utf8(dictionnaire.mot[ligne], TAILLE_LANGUE_1, "CP1252"));
		strcpy(dictionnaire.traduction[ligne], convertir_vers_utf8(dictionnaire.traduction[ligne], TAILLE_LANGUE_2, "CP1252"));
		ligne++;
	}
	fclose(wb);
	
	
	int i = 0;
	

	while(i < strlen(dictionnaire.nom_fichier)){
		if(dictionnaire.nom_fichier[i] == '_'){
			position_underscore = i;
		}
		if(dictionnaire.nom_fichier[i] == '.'){
			position_point = i;
		}
		
		i++;
	}
	
	dictionnaire.nom_langue1 = (char *)malloc((position_underscore)*sizeof(char *));
	dictionnaire.nom_langue2 = (char *)malloc((position_point - (position_underscore + 1))*sizeof(char *));
	
	strncpy(dictionnaire.nom_langue1, dictionnaire.nom_fichier, (position_underscore));
	dictionnaire.nom_langue1[position_underscore] = '\0';
	
	strncpy(dictionnaire.nom_langue2, (dictionnaire.nom_fichier + position_underscore + 1),(position_point - (position_underscore + 1)));
	dictionnaire.nom_langue2[position_point - (position_underscore + 1)] = '\0';

	printf(">Dictionnaire : %s / %s\n", dictionnaire.nom_langue1, dictionnaire.nom_langue2);
	
	free(location_fichier);
}


//////////////////////////////////////////////////////////////////////
//---------------------------chercher_mot---------------------------//
//////////////////////////////////////////////////////////////////////
// fonction pour chercher un mot dans le dictionnaire qui renvoie le
// l'indice du mot dans le dictionnaire ou -1 s'il n'est pas trouvé
int chercher_mot(char * mot){
	int i = 0;
	int trouve = 0;
	int res;
	
	while((trouve == 0) && (i < dictionnaire.nombre_mots)){
		res = strncmp(dictionnaire.mot[i], mot, strlen(mot));
		if(res == 0){
			trouve = 1;
		}else{
			i++;
		}
	}

	if(trouve == 1){
		return i;
	}else{
		return -1;
	}
}

//////////////////////////////////////////////////////////////////////
//--------------------vider_pEntry_recherche------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui vide le texte de pEntry_recherche
void vider_pEntry_recherche(){
	gtk_entry_set_text(GTK_ENTRY(pEntry_recherche), "");
}


//////////////////////////////////////////////////////////////////////
//------------------------afficher_dico-----------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui remplit les pEntry_mot et pEntry_traduction
void afficher_dico(int debut){	
	if(debut >= (dictionnaire.nombre_mots - NOMBRE_ENTRY)) debut = dictionnaire.nombre_mots - NOMBRE_ENTRY;
	for(int i = debut; i<(debut + NOMBRE_ENTRY); i++){
		gtk_entry_set_text(GTK_ENTRY(pEntry_mot[i-debut]), dictionnaire.mot[i]);
		gtk_entry_set_text(GTK_ENTRY(pEntry_traduction[i-debut]), dictionnaire.traduction[i]);
	}
}


//////////////////////////////////////////////////////////////////////
//----------------------actualiser_labels---------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui remplit les labels pLabel_langue1 et pLabel_langue2
// en fonction des rubriques nom_langue1, nom_langue2 du dictionnaire
void actualiser_labels(){
	
	char chaine[500];
	gchar * chaine_utf8;
	
	strcpy(chaine, "<span face='Verdana' foreground='#39b500' size='xx-large'><b>");
	strcat(chaine, dictionnaire.nom_langue1);
	strcat(chaine, "</b></span>");
	
	chaine_utf8 = g_locale_to_utf8(chaine, -1, NULL, NULL, NULL);  //Convertion du texte avec les balises

	gtk_label_set_label(GTK_LABEL(pLabel_langue1), chaine_utf8);
	
	strcpy(chaine, "<span face='Verdana' foreground='#39b500' size='xx-large'><b>");
	strcat(chaine, dictionnaire.nom_langue2);
	strcat(chaine, "</b></span>");
	
	chaine_utf8 = g_locale_to_utf8(chaine, -1, NULL, NULL, NULL);  //Convertion du texte avec les balises

	gtk_label_set_label(GTK_LABEL(pLabel_langue2), chaine_utf8);
	
    g_free(chaine_utf8); // Libération de la mémoire
}


//////////////////////////////////////////////////////////////////////
//---------------------actualiser_drapeaux--------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui actualise les images pImage_langue1 et pImage_langue2
// en fonction des rubriques nom_langue1, nom_langue2 du dictionnaire
void actualiser_drapeaux(){
	char nom_fichier[100];
	
	strcpy(nom_fichier, "./icones/");
	strcat(nom_fichier, dictionnaire.nom_langue1);
	strcat(nom_fichier, ".ico");
	
	gtk_image_set_from_file(GTK_IMAGE(pImage_langue1), nom_fichier);
	
	
	strcpy(nom_fichier, "./icones/");
	strcat(nom_fichier, dictionnaire.nom_langue2);
	strcat(nom_fichier, ".ico");
	
	gtk_image_set_from_file(GTK_IMAGE(pImage_langue2), nom_fichier);
}


//////////////////////////////////////////////////////////////////////
//-----------------actualiser_valeur_pScrollBar---------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui met la valeur de pScrollBar à i
void actualiser_valeur_pScrollBar(int i){
	/* Met le nombre la valeur du ScrollBar à i */
	gtk_range_set_value(GTK_RANGE(pScrollBar), i);
}


//////////////////////////////////////////////////////////////////////
//-----------------actualiser_range_pScrollBar----------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui met la valeur max de pScrollBar en fonction du nombre
// de mots du dictionnaire
void actualiser_range_pScrollBar(){
	/* Met le nombre de mots du dictionnaire en valeur max du ScrollBar */
	gtk_range_set_range(GTK_RANGE(pScrollBar), 0, dictionnaire.nombre_mots);
}

//////////////////////////////////////////////////////////////////////
//--------------------actualiser_barre_etat-------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui met le nom du fichier et le nombre de mots dans la barre d'état
void actualiser_barre_etat(){
	char * nombre_mots = (char *)malloc((sizeof(dictionnaire.nombre_mots)+5)*sizeof(char *));
	sprintf(nombre_mots, "%ld", dictionnaire.nombre_mots);
	strcat(nombre_mots, " mots");
	
	gtk_label_set_label(GTK_LABEL(pLabel_fichier), dictionnaire.nom_fichier);
	gtk_label_set_label(GTK_LABEL(pLabel_nombre_mots), nombre_mots);
	//free(nombre_mots);
}

//////////////////////////////////////////////////////////////////////
//--------------------actualiser_affichage--------------------------//
//////////////////////////////////////////////////////////////////////
// procédure appelle toutes les procédure d'affichage
void actualiser_affichage(int i){

	/* Labels */
	actualiser_labels();
	
	/* Drapeaux */
	actualiser_drapeaux();
	
	/* Mots */
	afficher_dico(i);

	/* ScrollBar */
	actualiser_valeur_pScrollBar(i);
	actualiser_range_pScrollBar();
	
	/* Barre d'état */
	actualiser_barre_etat();
	
	/* Donne le focus au widget pEntry_recherche s'il ne l'as pas déjà */
	/* je vérifie car s'il a déjà le focus ça va sélectionner le texte */
	if(gtk_window_get_focus(GTK_WINDOW(pMainWindow)) != pEntry_recherche) gtk_window_set_focus(GTK_WINDOW(pMainWindow), pEntry_recherche);
}

//////////////////////////////////////////////////////////////////////
//--------------------------flength---------------------------------//
//////////////////////////////////////////////////////////////////////
// Fonction pour obtenir la taille d'un fichier
long flength(FILE *f){

	/* Variables */
	long fin;

	fseek(f, 0, SEEK_END);	// on se déplace à la fin du fichier
	fin = ftell(f);			// on met la position du curseur dans la variable fin
	
	rewind(f);	// retourne au début du fichier

	return fin;
}


//////////////////////////////////////////////////////////////////////
//--------------------convertir_vers_utf8---------------------------//
//////////////////////////////////////////////////////////////////////
// fonction qui converti une chaîne d'encodage du dernier paramètre en
// encodage UTF-8
char * convertir_vers_utf8(char * chaine, size_t taille, char * encodage){
	
	char * p_chaine = chaine;

	size_t taille2 = taille * 2; 									// je réserve le double d'espace car en utf8,
	char * texte_converti = (char *)malloc(taille2*sizeof(char *));	// les caractères accentués prennent 2octets
	char * p_texte_converti = texte_converti;
	
	iconv_t conv_desc;
	
	conv_desc = iconv_open("UTF-8", encodage);	// génère un descripteur de conversion encodage -> utf8
	iconv (conv_desc, &p_chaine , &taille, &p_texte_converti, &taille2);	// converti la valeur pointée par p_chaine
																			// et met le resultat a l'adresse de texte_converti
	iconv_close(conv_desc);	// ferme la session de conversion
	
	return texte_converti;
}


//////////////////////////////////////////////////////////////////////
//------------------------OnRecherche-------------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui se déclenche dès qu'on change la valeur de pEntry_recherche
// et fait appel à la fonction chercher_mot
void OnRecherche(GtkEntry *entry){
	char * mot = (char *)gtk_entry_get_text(GTK_ENTRY(pEntry_recherche));

	int	i = chercher_mot(mot);
	
	if(i != -1){
		actualiser_affichage(i);
		printf("trouvé : %d : %s\n", i, dictionnaire.mot[i]);
	}else{
		printf("non trouvé\n");
	}
}


//////////////////////////////////////////////////////////////////////
//---------------------OnScrollbarChange----------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui se déclenche dès qu'on change la valeur de pScrollBar
// et qui fait appel à la procédure afficher_dico à partir de l'indice voulu
void OnScrollbarChange(GtkWidget *pWidget){
	gint iValue;
	
	/* Recuperation de la valeur de la scrollbar */
	iValue = gtk_range_get_value(GTK_RANGE(pWidget));
	
	afficher_dico(iValue);
	
}


//////////////////////////////////////////////////////////////////////
//-----------------------OnIntervertir------------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui se déclenche dès qu'on appuye sur le bouton pBouton_intervertir
// qui change la valeur de la rubrique nom_fichier et fait appel à charger_dico
void OnIntervertir(GtkWidget *pWidget){
	char * nom_fichier = (char *)malloc((strlen(dictionnaire.nom_fichier))*sizeof(char*));
	
	strcpy(nom_fichier, dictionnaire.nom_langue2);
	strcat(nom_fichier,"_");
	strcat(nom_fichier, dictionnaire.nom_langue1);
	strcat(nom_fichier,".wb");
	
	dictionnaire.nom_fichier = nom_fichier;
	
	vider_pEntry_recherche(); 	// Efface la derniere recherche
	charger_dico();
	actualiser_affichage(0);	
	
}


//////////////////////////////////////////////////////////////////////
//--------------------------OnAbout---------------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui affiche une boite de dialogue lorsque l'on appuye sur
// le menu à propos
void OnAbout(GtkWidget* widget){
    GtkWidget *pAbout;

    pAbout = gtk_message_dialog_new (GTK_WINDOW(pMainWindow),
        GTK_DIALOG_MODAL,
        GTK_MESSAGE_INFO,
        GTK_BUTTONS_OK,"Dictionnaire freelang\n©Beaumont 1997-2005\nhttp://www.freelang.com\nBeaumont@freelang.com\nVersion Linux(Gnome)\npar Guillaume Dadoy");

    gtk_dialog_run(GTK_DIALOG(pAbout));

    gtk_widget_destroy(pAbout);
}


//////////////////////////////////////////////////////////////////////
//--------------------------OnOuvrir--------------------------------//
//////////////////////////////////////////////////////////////////////
// procédure qui affiche une boite de dialogue d'ouverture de fichier
// lorsqu'on appuye sur le menu Ouvrir et qui chagre le fichier voulu
void OnOuvrir(GtkWidget *pWidget){
    GtkWidget *pFileSelection;
    GtkFileFilter * pfilter;
    gchar *sChemin;
    gchar *sCheminFichier;

    /* Creation de la fenetre de selection */
    pFileSelection = gtk_file_chooser_dialog_new("Ouvrir un dictionnaire",
	GTK_WINDOW(pMainWindow),
	GTK_FILE_CHOOSER_ACTION_OPEN,
	GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	GTK_STOCK_OPEN, GTK_RESPONSE_OK,
	NULL);
    /* On limite les actions a cette fenetre */
    gtk_window_set_modal(GTK_WINDOW(pFileSelection), TRUE);
	

	
	/* On précise le dossier courrant "./langue/" */
	sChemin = (gchar *)malloc((strlen(gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(pFileSelection)))+8)*sizeof(gchar *));
	strcpy(sChemin, gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(pFileSelection)));
	strcat(sChemin,"/langue");
	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(pFileSelection), sChemin);
	
            
	// Application d'un filtre pour n'autoriser que le chargement des fichiers .wb
	pfilter = gtk_file_filter_new ();
	gtk_file_filter_add_pattern (pfilter, "*.wb");
	gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(pFileSelection), pfilter);
	

    /* Affichage fenetre */
    switch(gtk_dialog_run(GTK_DIALOG(pFileSelection))){
        case GTK_RESPONSE_OK:
            /* Recuperation du chemin */

			sCheminFichier = (gchar *)malloc((strlen(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(pFileSelection))))*sizeof(gchar *));
            strcpy(sCheminFichier,gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(pFileSelection)));
			
			dictionnaire.nom_fichier = (sCheminFichier + strlen(sChemin) + 1);	// récupère le nom de fichier seul
			
			vider_pEntry_recherche(); 	// Efface la derniere recherche
            
            printf("fichier chargé : \"%s\"\n", dictionnaire.nom_fichier);
            
            charger_dico();
            
            actualiser_affichage(0);
		    g_free(sChemin);
		    g_free(sCheminFichier);
            break;
        default:
            break;
    }
    gtk_widget_destroy(pFileSelection);
}

